Scheduling a Batching Machine

We address the problem of scheduling n jobs on a batching machine to minimize regular scheduling criteria that are non-decreasing in the job completion times. A batching machine is a machine that can handle up to b jobs simultaneously. The jobs that are processed together form a batch, and all jobs in a batch start and complete at the same time. The processing time of a batch is equal to the largest processing time of any job in the batch. We analyze two variants: the unbounded model, where b n; and the bounded model, where b < n. For the unbounded model, we give a characterization of a class of optimal schedules, which leads to a generic dynamic programming algorithm that solves the problem of minimizing an arbitrary regular cost function in pseudopolynomial time. The characterization leads to more e cient dynamic programming algorithms for speci c cost functions: a polynomial algorithm for minimizing the maximum cost, an O(n3) time algorithm for minimizing the number of tardy jobs, an O(n2) time algorithm for minimizing the maximum lateness, and an O(n logn) time algorithm for minimizing the total weighted completion time. Furthermore, we prove that minimizing the weighted number of tardy jobs and the total weighted tardiness are NP-hard problems. For the bounded model, we derive an O(nb(b 1)) time dynamic programming algorithm for minimizing total completion time when b > 1; for the case with m di erent processing times, we give a dynamic programming algorithm that requires O(b2m22m) time. Moreover, we prove that due-date based scheduling criteria give rise to NP-hard problems. Finally, we show that an arbitrary regular cost function can be minimized in polynomial time for a xed number of batches. The problem of scheduling n independent jobs on a batching machine to minimize regular scheduling criteria is considered. A batching machine or batch processing machine is a machine that can process up to b jobs simultaneously, and a regular scheduling criterion is one that is non-decreasing in the job completion times. The jobs that are processed together form a batch. Speci cally, we are interested in the so-called burn-in model, in which the processing time of a batch is equal to the maximum processing time of any job assigned to it. All jobs contained in the same batch start and complete at the same time, since the completion time of a job is equal to the completion time of the batch to which it belongs. This model is motivated by the problem of scheduling burn-in operations for large scale integrated circuit manufacturing; see Lee et al. (1992). Webster and Baker (1995) present an overview of algorithms and complexity results for scheduling batch processing machines. They distinguish three types of models: the burn-in model; the model in which the processing time of a batch is equal to the sum of the processing times of its jobs (see also Albers and Brucker, 1993); and the model in which the processing time of a batch is a constant, independent of the jobs it contains (see also Ahmadi et al., 1992). We analyze two variants of the burn-in model: the unbounded model, in which b n so that there is e ectively no upper bound on the number of jobs that can be processed in the same batch; and the bounded model, in which b is a constant smaller than n so that there is a restrictive upper bound. The unbounded model arises for instance in situations where compositions need to be hardened in kilns, and the kiln is su ciently large that it does not restrict batch sizes. We assume throughout that the jobs and the machine are available from time zero onwards, or equivalently, the jobs have equal release dates. Note that the special case b = 1 concurs with the classical single-machine scheduling model in which the machine can handle no more than one job at a time. Accordingly, the bounded model gives rise to problems that are at least as di cult as their traditional counterparts. For the unbounded model, we give a characterization of a class of optimal schedules, which leads to a generic dynamic programming algorithm for minimizing any regular cost functionPnj=1 fj . This algorithm requires O(n2P ) time and O(nP ) space, where P is the sum of the job processing times. The characterization forms the basis of polynomial dynamic programming algorithms for speci c cost functions. We present an O(n3) time algorithm for minimizing the number of tardy jobs Pnj=1 Uj , an O(n logn) time algorithm for minimizing total weighted completion time Pnj=1 wjCj, and an O(n2) time algorithm for minimizing the maximum lateness Lmax. The latter algorithm can be used to construct a polynomial algorithm for minimizing the maximum cost fmax. Furthermore, we prove that minimizing the weighted number of tardy jobs Pnj=1 wjUj and the total weighted tardiness Pnj=1 wjTj are NP-hard problems. As to the bounded model, Lee et al. (1992) and Uzsoy (1995) present polynomial algorithms for minimizing the number of tardy jobsPnj=1 Uj and the maximum lateness Lmax under a number of assumptions on the relationship between processing times, job release dates, and due dates; see also Cheng and Kovalyov (1995). Minimizing total completion time Pnj=1 Cj is undoubtedly the most vexing bounded problem. Chandru et al. (1993a, 1993b) present heuristics and a branch-andbound algorithm as well as an O(m3bm+1) time dynamic programming algorithm for the case of m di erent job processing times (m < n). Hochbaum and Landy (1994) present a faster algorithm that requires O(m23m) time and O(m3m) space. We prove that minimizing total completion timePnj=1 Cj is solvable in polynomial time for xed b, where b > 1, by deriving an O(nb(b 1)) time dynamic programming algorithm for its solution. (The special case where b = 1 is a classical scheduling problem that is solvable in O(n logn) 1 time.) For the case of m di erent processing times, we give a more e cient dynamic programming algorithm than that of Hochbaum and Landy: ours requires O(b2m22m) time. Furthermore, we prove that other criteria give rise to NP-hard problems. There are two exceptions: minimizing makespan Cmax is solvable in minfO(n logn); O(n2=b)g time, while minimizing total completion time Pnj=1Cj for arbitrary b, and minimizing total weighted completion time Pnj=1 wjCj for xed and arbitrary b are open problems. Finally, we give a polynomial algorithm for minimizing any regular cost function for the special case in which the number of batches is xed. Table 1 summarizes our main results. For sake of comparison, we have included the time complexities of the classical scheduling problems, i.e., problems with b = 1; see also Lawler et al. (1993). Objective Unbounded Bounded function b n b = 1 b 2 fmax polynomial O(n2) unary NP-hard Cmax O(n) O(n) minfO(n logn); O(n2=b)g Lmax O(n2) O(n logn) unary NP-hard O(n2P ) Pnj=1 fj binary NP-hard unary NP-hard unary NP-hard Pnj=1 Cj O(n logn) O(n logn) O(nb(b 1)) Pnj=1 wjCj O(n logn) O(n logn) open Pnj=1 Uj O(n3) O(n logn) unary NP-hard O(n2P ) O(nP ) Pnj=1 wjUj binary NP-hard binary NP-hard unary NP-hard O(n2P ) O(n4P ) Pnj=1 Tj open binary NP-hard unary NP-hard O(n2P ) Pnj=1 wjTj binary NP-hard unary NP-hard unary NP-hard Table 1: Overview of time complexities for problems with equal release dates. The plan of the rest of paper is as follows. In Section 1, we give a formal description of the model, introduce our notation, and give some de nitions. We analyze the unbounded model in Section 2 and the bounded model in Section 3. In Section 4, we conclude by summarizing our results and point out the consequences for problems with unequal release dates and parallel machines. 1 Problem description, notation, and de nitions The scheduling model that we analyze is as follows. There are n independent jobs J1; : : : ; Jn that have to be scheduled on a single batching machine. Each job Jj (j = 1; : : : ; n) requires processing during at least a given non-negative uninterrupted time pj , and is available for processing from time zero onwards. Also, each job Jj has a cost function fj , where fj(t) denotes the cost incurred if the job is completed at time t. Throughout this paper, we consider only regular cost functions, i.e., we assume that fj(t) is a non-decreasing function of t, for j = 1; : : : ; n. Sometimes, each job Jj has a due date dj by which it should ideally be completed, a deadline dj by which it must be completed, and a weight wj which is a measure of its importance; when there is ambiguity, we state 2 explicitly whenever due dates, deadlines or weights are present. The weights and due dates are typically used to de ne cost objective functions; the deadlines restrict the availability of jobs. The batching machine is available from time zero onwards and can process up to b jobs simultaneously. All jobs in a batch start and complete at the same time. The processing time of a batch is equal to the largest processing time of any job in the batch. Without loss of generality, we assume that the job parameters are integral, unless stated otherwise. For problems of minimizing a regular objective function without job release dates, we know that there must be at least one optimal solution in which the batches are processed contiguously from time zero onwards. Throughout the paper, we restrict attention to solutions with this property. Thus, a schedule is a sequence of batches = (B1; : : : ;Br), where each batch Bl (l = 1; : : : ; r) is a set of jobs. The processing time of batch Bl is p(Bl) = maxJj2Blfpjg and its completion time is C(Bl) =Plq=1 p(Bq). Note that the completion time of job Jj in , for each Jj 2 Bl and l = 1; : : : ; r, is Cj( ) = C(Bl). When there is no ambiguity, we abbreviate Cj( ) to Cj. The aim is to minimize the scheduling cost, measured either by a regular minmax objective function fmax = max1 j nffj(Cj)g, or by a regular minsum objective function Pnj=1 fj =Pnj=1 fj(Cj). Speci c regular objective functions that we consider are the makespan Cmax, de ned as Cmax = max1 j nfCjg; maximum lateness Lmax, de ned as Lmax = max1 j nfCj djg; total weighted completion time Pnj=1 wjCj ; total weighted tardiness Pnj=1 wjTj , where Tj = maxfCj dj ; 0g; and weighted number of tardy jobs Pnj=1 wjUj , where Uj is an 0-1 indicator variable that takes the value 1 if Jj is tardy, i.e., if Cj > dj , and the value 0 if Jj is on time, i.e., if Cj dj . We also provide results for the unweighted versions of these minsum objective functions in which wj = 1 for j = 1; : : : ; n. 2 The unbounded model In this section, we assume that b n and hence that the batching machine can process any number of jobs at the same time. Note that the problem of minimizing the makespan is solved trivially by putting all jobs in one batch B1. The minimum makespan is then Cmax = p(B1) = max1 j nfpjg. For the remainder of this section, we assume throughout that the jobs have been re-indexed according to the shortest processing time (SPT) rule so that p1 : : : pn. 2.1 Fundamentals We rst derive a most useful characterization of a class of optimal solutions for minimizing any regular objective function. Lemma 1 For minimizing any regular objective function, there exists an optimal schedule (B1; : : : ;Br), where under the SPT indexing Bl = fJjl ; Jjl+1; : : : ; Jjl+1 1g and 1 = j1 < j2 < : : : < jr < jr+1 = n+ 1. Proof. Consider any optimal schedule = (B1; : : : ;Bl; : : : ;Bq; : : : ;Br), where 1 l < q r, with Jk 2 Bl, Jj 2 Bq, and pk > pj . Consider now the schedule 0 = (B1; : : : ;Bl [ fJjg; : : : ;Bq n fJjg; : : : ;Br) that is obtained from by moving job Jj to batch Bl. Since pj < pk, we have that p(Bl[fJjg) = p(Bl) and p(Bq nfJjg) p(Bq). Accordingly, the completion time of job Jj decreases from C(Bq) to C(Bl), while the completion times of the other jobs do not increase. Since the 3 objective function is regular, the new schedule 0 is also optimal. A nite number of repetitions of this procedure yields an optimal schedule of the required form. Lemma 1 shows that an optimal schedule is speci ed by the jobs that start each batch, since the complete schedule can then be formed by the SPT rule. We refer to such a schedule as an SPTbatch schedule. The observation that we may restrict our search to SPT-batch schedules forms the basis of a pseudopolynomial dynamic programming algorithm for minimizing any regular minsum objective function Pnj=1 fj , and a polynomial algorithm for minimizing a class of regular minmax objective functions fmax. A dynamic programming algorithm can be built around di erent types of enumeration schemes. We can use either a forward scheme in which jobs or batches are successively added to the end of the current (partial) schedule, or a backward scheme in which jobs or batches are added to the beginning. The schedule can be constructed by adding either complete batches or single jobs. We start by explaining in general terms the optimality principle and the working of a generic forward dynamic programming algorithm with batch enumeration for a regular minsum objective function Pnj=1 fj or a regular minmax objective function fmax. Consider any feasible SPT-batch schedule containing jobs J1; : : : ; Jj with the property that the last batch completes at time t. We de ne such a schedule to be in state (j; t). Of course, to schedule the remaining jobs Jj+1; : : : ; Jn, we need to consider only a schedule that has minimum objective value among all schedules in this state. Let be an SPT-batch schedule with minimum objective value from among all schedules in state (j; t). To achieve this state from a previous state, the following decision must be taken to create : add a batch containing Jj. A batch fJi+1; : : : ; Jjg, where 0 i < j, is added to the end of some previous schedule that contains jobs J1; : : : ; Ji. Since batch fJi+1; : : : ; Jjg has processing time pj , the previous state is (i; t pj). Adding this batch to the previous schedule increases the total cost by Pjk=i+1 fk(t); the maximum cost of jobs Ji+1; : : : ; Jj is maxi+1 k jffk(t)g. This optimality principle leads to a pseudopolynomial O(n3Pnj=1 pj) time dynamic programming algorithm for minimizing any regular objective function, since the state variables are (j; t) for j = 0; : : : ; n and t = 0; : : : ;Pni=1 pi, and there are j possible batches that can be added to achieve state (j; t). To implement this algorithm more e ciently for an arbitrary regular minsum objective function, partial sums Pjk=1 fk(t) are evaluated and stored in a preprocessing step, which reduces the time complexity to O(n2Pnj=1 pj). Details of such an algorithm are given in Section 2.2. To minimize the number of tardy jobs, we develop a polynomial algorithm by eliminating the state variable t. Since the number of tardy jobs cannot exceed n, we reverse the role of the state variable t and the objective function value. To achieve the O(n3) time complexity, we build the schedule by adding single jobs instead of complete batches. Full details are presented in Section 2.3. To construct a polynomial algorithm for other objective functions, we develop a generic backward dynamic programming algorithm which allows us to avoid the state variable t. In a backward algorithm, the batches are constructed in the reverse order to which they appear in the schedule. Using this approach, we obtain polynomial algorithms for minimizing the total weighted completion time Pnj=1 wjCj and the maximum lateness Lmax. We de ne a cost function fj to be additive if fj(t + ) = fj(t) + fj( ) for any , and to be incremental if fj(t + ) = fj(t) + for any . An objective function is additive if each fj 4 is additive, and is incremental if each fj is incremental (j = 1; : : : ; n). Note that total weighted completion time is additive, and maximum lateness is incremental. A backward dynamic programming algorithm with batch enumeration for an additive regular minsum objective functionPnj=1 fj or an incremental regular minmax objective function fmax works as follows. Let be an SPT-batch schedule for the jobs Jj ; : : : ; Jn, where processing of the rst batch starts at time zero; we de ne such a schedule to be in state j. To achieve this state from a previous state, the following decision must be taken to create : add a batch containing Jj. A batch fJj ; : : : ; Jk 1g, where j < k n + 1, is inserted at the beginning of some previous schedule in state k. Since batch fJj ; : : : ; Jk 1g has processing time pk 1, jobs Jk ; : : : ; Jn are completed pk 1 units later when this batch is added. For an additive objective function, the total cost increases by Pni=j fi(pk 1); for an incremental objective function, the maximum cost of jobs Jk; : : : ; Jn increases by pk 1, and the maximum cost of jobs in batch fJj ; : : : ; Jk 1g is maxj i k 1ffi(pk 1)g. Using a backward recursion, we obtain an O(n logn) algorithm for minimizing total weighted completion time in Section 2.4, and an O(n2) algorithm for minimizing the maximum lateness in Section 2.5. 2.2 Minimizing a regular minsum function In this section, we formalize the generic forward dynamic programming algorithm with batch enumeration that is outlined in Section 2.1 for the problem of minimizing an arbitrary regular minsum objective function Pnj=1 fj . We show that this problem can be solved in O(n2P ) time and O(nP ) space, where P =Pnj=1 pj . Let Fj(t) be the minimum objective value for SPT-batch schedules containing jobs J1; : : : ; Jj subject to the condition that the last batch completes at time t. Recall from Section 2.1 that, given Fj(t) and any SPT-batch schedule corresponding to this value, batch fJi+1; : : : ; Jjg, for some i where 0 i < j, appears in the last position. We are now ready to give our dynamic programming recursion. The initialization is F0(t) = 0; if t = 0, 1 otherwise, and the recursion for j = 1; : : : ; n and t = pj ; : : : ;Pjk=1 pk is Fj(t) = min 0 i j 1nFi(t pj) + j X k=i+1 fk(t)o: The optimal solution value is equal to minpn t P fFn(t)g, and the corresponding optimal schedule is found by backtracking. To implement the algorithm e ciently, the partial sums Pjk=1 fk(t) are evaluated and stored for j = 1; : : : ; n and t = pj ; : : : ;Pjk=1 pk in a preprocessing step in O(nP ) time. Then, each application of the recursion equation requires O(n) time. Thus, the dynamic algorithm requires O(n2P ) time and O(nP ) space. 5 2.3 Minimizing the number of tardy jobs In this section, we present an O(n3) time dynamic programming algorithm for the problem of minimizing the number of tardy jobs. It is a forward algorithm that di ers from the generic pseudopolynomial procedure of Section 2.1 on two counts. First, we use the objective value as a state variable and the makespan as the value of a state; this swap alone is su cient to develop an O(n4) algorithm. Second, to obtain an O(n3) time algorithm, we build the schedule by adding single jobs instead of complete batches and x the last job to be scheduled in the current batch. We de ne a schedule for jobs J1; : : : ; Jj to be in state (j; u; k), where u j k, if it contains exactly u tardy jobs, and the last batch is to be enlarged by including jobs Jj+1; : : : ; Jk, but no others. Thus, a schedule is to be created in which jobs Jj ; : : : ; Jk are contained in the same batch, and this batch has processing time pk. Let Fj(u; k) be the minimum makespan for SPT-batch schedules in state (j; u; k). A schedule in state (j; u; k) with value Fj(u; k), is created by taking one of the following decisions in a previous state: add job Jj so that it does not start the last batch. The last batch to which Jj is added includes job Jj 1 and has processing time pk. This processing time pk contributes to the makespan of the previous state, which is Fj 1(u; k) or Fj 1(u 1; k) depending on whether Jj is on time or tardy. If Fj 1(u; k) dj , then we consider (j 1; u; k) as a previous state with Jj scheduled to be on time; if Fj 1(u 1; k)> dj , then we consider (j 1; u 1; k) as a previous state with Jj scheduled to be tardy. add job Jj so that it starts the last batch. The previous batch ends with job Jj 1 and the processing time of the new batch is pk. After adding the contribution from the previous state, the makespan becomes Fj 1(u; j 1) + pk or Fj 1(u 1; j 1) + pk, depending on whether Jj is on time or tardy. If Fj 1(u; j 1) + pk dj , then we consider (j 1; u; j 1) as a previous state with Jj scheduled to be on time; if Fj 1(u 1; j 1)+pk > dj , then we consider (j 1; u 1; j 1) as a previous state with Jj scheduled to be tardy. We are now ready to give the dynamic programming recursion. The initialization is F0(u; k) = 0; if u = 0 and k = 0, 1; otherwise, and the recursion for j = 1; : : : ; n, u = 0; : : : ; j, and k = j; : : : ; n is Fj(u; k) = min8>>><>>>:Fj 1(u; k); if Fj 1(u; k) dj , Fj 1(u 1; k); if Fj 1(u 1; k) > dj , Fj 1(u; j 1) + pk; if Fj 1(u; j 1) + pk dj , Fj 1(u 1; j 1) + pk; if Fj 1(u 1; j 1) + pk > dj , 1; otherwise. The minimum number of tardy jobs is then equal to the value smallest value u for which Fn(u; n) < 1, and the corresponding optimal schedule is found by backtracking. Note that the algorithm requires O(n3) time and O(n3) space. 2.4 Minimizing total weighted completion time In this section, we present an O(n logn) time dynamic programming algorithm for minimizing the total weighted completion time Pnj=1 wjCj . Since we have an additive minsum objective function, the generic backward dynamic programming algorithm of Section 2.1 can be used. 6 Let Fj be the minimum total weighted completion time for SPT-batch schedules containing the last n j + 1 jobs Jj ; : : : ; Jn. Processing of the rst batch in the schedule starts at time zero. Furthermore, whenever a new batch is added to the beginning of this schedule, there is a corresponding delay to the processing of all batches. Suppose that a batch fJj ; : : : ; Jk 1g, which has processing time pk 1, is inserted at the start of a schedule for jobs Jk ; : : : ; Jn. The total weighted completion time of jobs Jk; : : : ; Jn increases by pk 1Pni=k wi, while the total weighted completion time for jobs Jj ; : : : ; Jk 1 is pk 1Pk 1 i=j wi. Thus, the overall increase in total weighted completion time is pk 1Pni=j wi. We are now ready to give the dynamic programming recursion. The initialization is Fn+1 = 0; and the recursion for j = n; n 1; : : : ; 1 is Fj = min j 1 can be processed together with it in B1. Accordingly, Jm+2 is processed in 8 batch B2, which cannot begin before time 2A, the earliest possible completion time of B1. Since Jm+2 has to be completed by its due date 7A, neither job Jj nor Jm+j with j > 2 can be processed together with it in B2. Further, the earliest completion time of B2 is 6A, so job J1 is tardy if it is processed in B2. Repeating this line of reasoning, we deduce that each `heavy' job Jm+j and each on-time `light' job Jj are assigned to batch Bj , for j = 1; : : : ; m. Moreover, we assume without loss of generality that each tardy `light' job is assigned to batch Bm+1. If job Jj is assigned to batch Bj , then p(Bj) = 2jA + aj ; otherwise, p(Bj) = 2jA. Let X and Y denote the set of indices j (j = 1; : : : ; m) for which Jj 2 Bj and Jj = 2 Bj , respectively. To ensure that job J2m is on time, we require that C(Bm) = Pmj=1 2jA+Pj2X aj (m2 +m+ 1)A. Thus, Pj2X aj A. The condition Pnj=1 wjUj A implies that Pj2Y aj A, or equivalently Pj2X aj A. Therefore,Pj2X aj = A, which shows that X and Y de ne a solution to Partition. 2.7 Minimizing total weighted tardiness For minimizing the total weighted tardiness, we obtain a similar result to that for minimizing the weighted number of tardy jobs. This problem is solvable in pseudopolynomial time O(n2P ), which is shown in Section 2.2, and is NP-hard in the ordinary sense, which we prove here. Hence, a pseudopolynomial algorithm for its solution is the best we can achieve, unless P = NP. Theorem 2 The unbounded problem of minimizing the total weighted tardiness Pnj=1 wjTj is binary NP-hard. Proof. Our proof proceeds again by a reduction from Partition; see Section 2.6. For (our) convenience, we describe the construction using fractional weights. By multiplying all weights with a suitable number, however, we can obtain a proof with integral parameters only. Given an instance of Partition, we construct an instance of the unbounded total weighted tardiness problem with n = 2m jobs and b = n. For each j (j = 1; : : : ; m), we de ne a `light' job Jj with pj = 2jmA2 + aj , wj = aj=(2(j + 1)mA2), and dj = A + j(j + 1)mA2, and a `heavy' job Jm+j with pm+j = 2jmA2, wm+j = A+ 1, and dm+j = A + j(j + 1)mA2. Note that Jj and Jm+j have the same due date, for j = 1; : : : ; m. We prove that Partition has a solution if and only if there is a schedule for the corresponding instance of the total weighted tardiness problem with Pnj=1 wjTj A. First, suppose that X and Y de ne a solution to Partition. We assume without loss of generality that m 2 X . Consider a schedule with m batches which is constructed as follows. Each `light' job Jj , for j = 1; : : : ; m, is assigned to batch Bj if j 2 X , and is assigned to batch Bj+1 if j 2 Y . The `heavy' jobs Jm+1; : : : ; J2m are assigned to batches B1; : : : ;Bm respectively. The processing time of batch Bj , for j = 1; : : : ; m, is either 2jmA2+aj or 2jmA2 depending on whether or not j 2 X . Since C(Bj) Pji=1 2imA2+Pi2X ai = dj = dm+j for j = 1; : : : ; m, each `heavy' job and each `light' job Jj for j 2 X are on time. Moreover, each `light' job Jj for j 2 Y is completed at time Cj = C(Bj+1), where C(Bj+1) Pj+1 i=1 2imA2 > dj and is therefore tardy. Further, Cj Pj+1 i=1 2imA2 +Pi2X ai = dj+1 for j 2 Y . Therefore, Pnj=1 wjTj Pj2Y wj(dj+1 dj) = Pj2Y wj(2j + 2)mA2 =Pj2Y aj = A. Conversely, assume that there exists a schedule with Pnj=1 wjTj A. In any such schedule, all `heavy' jobs have to be on time. Also, as in the proof of Theorem 1, it is straightforward to show that in any such schedule each `heavy' job Jm+j and each on-time `light' job Jj are assigned to 9 batch Bj , and each tardy `light' job is assigned to one of the batches Bj+1; : : : ;Bm+1, where Bm+1 is a nal batch that contains only tardy jobs. If job Jj is assigned to batch Bj , then p(Bj) = 2jmA2 + aj ; otherwise, p(Bj) = 2jmA2. Let X and Y denote the set of indices j (j = 1; : : : ; m) for which Jj 2 Bj and Jj = 2 Bj , respectively. To ensure that job J2m is on time, we require that C(Bm) =Pmj=1 2jmA2+Pj2X aj A+m2(m+1)A2. Thus, Pj2X aj A. Each tardy `light' job Jj , where j 2 Y , is assigned to one of the batches Bj+1; : : : ;Bm+1. Hence, for j 2 Y , we have Cj Pj+1 i=1 2imA2, Tj 2(j + 1)mA2 A and wjTj aj aj=((2j + 2)mA) > aj 1=(2m). Therefore,Pnj=1 wjTj >Pj2Y(aj 1=(2m))>Pj2Y aj 1. Since the aj 's are integral andPnj=1 wjTj A, we must have also thatPj2Y aj A, or equivalently Pj2X aj A. Therefore, Pj2X aj = A, which shows that X and Y de ne a solution to Partition. 3 The bounded model In this section, we analyze problems in which b is restrictively small: we assume that b < n. These bounded problems are at least as di cult as their traditional counterparts, since for the special case b = 1 the machine can handle no more than one job at a time. They are also inherently much more di cult than their unbounded counterparts, mainly for reason that we can no longer restrict ourselves to SPT-batch schedules in the search for an optimal schedule. There is one exception: for minimizing makespan, there is a still an SPT-batch schedule that is optimal. For the bounded problem of minimizing the makespan, we assume that n is an integer multiple of b and that n = br. This assumption is justi ed by the observation that dummy jobs with zero processing time can be introduced without a ecting the minimum makespan. The problem is solved by assigning the b jobs with smallest processing times to B1, the b jobs with the next smallest processing times to B2, and so on, until the b jobs with largest processing times are assigned to Br. Hence, we can solve the problem in O(n logn) time, if we rst order the jobs using the SPT rule. Alternatively, we can solve the problem in O(rn) time, if we use linear time median nding techniques (Blum et al., 1973, Schonh age et al., 1976). More precisely, we can determine B1 [ : : : [ Bl, for l = 1; : : : ; r, by nding some job Jj in O(n) time such that jfijpi < pjgj < bl and jfijpi > pjgj < b(r l) and then introducing a subset of fijpi = pjg into the rst set so that its cardinality is exactly equal to bl. Under this implementation, the problem is solved in O(n2=b) time. In Section 3.1, we analyze the problem of minimizing total completion time. We show that the problem can be solved in O(nb(b 1)) time by dynamic programming for b > 1. Furthermore, we give an O(b2m22m) time algorithm for the case of m di erent processing times. We also provide complexity results for scheduling with due dates. Speci cally, we show in Section 3.2 that nding whether there is a feasible solution to the bounded problem in which the jobs have deadlines is NP-complete in the strong sense, even if b = 2. This result implies that minimizing the maximum lateness, the number of tardy jobs, and the total tardiness are all unary NP-hard problems. Finally, Section 3.3 addresses the special case in which the number of batches to be used is xed. We show that bounded problems of this type can be solved in O(nr+3) time, where r is the given number of batches. 10 3.1 Minimizing total completion time The bounded problem of minimizing total completion time is introduced by Chandru et al. (1993a), who present a branch-and-bound algorithm and some heuristics. We show in Section 3.1.1 that the general problem is solvable in O(nb(b 1)) time and O(nb(b 1)) space for b > 1. For the case of m di erent job types (where m < n), Chandru et al. (1993b) present an O(m3bm+1) time dynamic programming algorithm. Hochbaum and Landy (1994) present a more e cient algorithm that requires O(m23m) time and O(m3m) space. In Section 3.1.2, we present an algorithm with a further gain in e ciency: our algorithm requires O(b2m22m) time and O(bm2) space. Throughout this section, we again assume that the jobs have been re-indexed according to the SPT rule so that p1 : : : pn. The following result shows that there exists an optimal schedule in which each batch contains jobs with consecutive indices. Lemma 2 There exists an optimal schedule (B1; : : : ;Br) for which, under the SPT indexing, Bl = fJil ; : : : ; Jjlg, where 1 il jl n, for l = 1; : : : ; r. Proof. Consider any optimal schedule = (B1; : : : ;Bl; : : : ;Br), where 1 l r, with Ji; Jj 2 Bl, where i < j 1, and Jj 1 = 2 Bl. Suppose that Jj 1 2 Bq for some q 6= l. Consider now the schedule 0 that is obtained from by interchanging jobs Ji and Jj 1, thereby changing Bl to Bl[fJj 1gnfJig and Bq to Bq [ fJig n fJj 1g. Since pi pj 1 pj , we have that p(Bl [ fJj 1g n fJig) = p(Bl) and p(Bq [ fJig n fJj 1g) p(Bq). Thus, no batch has a larger completion time in 0 than in , and batch sizes are the same in and 0. It follows that the total completion time for 0 does not exceed that for , and the new schedule 0 is also optimal. A nite number of repetitions of this procedure yields an optimal schedule of the required form. We now present a result of Chandru et al. (1993b) which extends the classical SWPT rule for sequencing jobs on a single machine to the sequencing of batches. Lemma 3 (Chandru et al., 1993b) For given batches B1; : : : ;Br, an optimal sequence is (B1; : : : ;Br) if and only if p(B1)=jB1j : : : p(Br)=jBrj: (1) We de ne a batch to be full if it contains exactly b jobs; otherwise, it is non-full. Also, a batch Bl is deferred with respect to another batch Bq if Bl is sequenced after Bq and p(Bl) < p(Bq). We now derive a result relating to deferred batches. Lemma 4 In any optimal schedule, there is no batch that is deferred with respect to a non-full batch. Proof. Consider any schedule which contains a batch Bl which is deferred with respect to a non-full batch Bq. Any job in Bl can be moved to Bq without a ecting feasibility and without increasing the processing time of batch Bq. Since such a transformation decreases the total completion time, the desired result is established. In our subsequent analysis, we only consider schedules that are consistent with the above lemmas: each batch contains jobs with consecutive indices; batches are ordered according to (1); and no batch is deferred with respect to a non-full batch. 11 3.1.1 A polynomial algorithm for xed b In this subsection, we derive a polynomial algorithm for the bounded problem of minimizing the total completion time. The special case b = 1 is equivalent to the corresponding classical scheduling problem for which the SPT rule provides an optimal solution in O(logn) time. Thus, we assume that b 2, and derive an O(nb(b 1)) dynamic programming algorithm. This algorithm relies an upper bound on the number of deferred batches, which we establish next. Lemma 5 In any optimal schedule, the number of deferred batches with respect to any full batch does not exceed b2 b 1. Proof. Consider any schedule for which the number of deferred batches with respect to some full batch Bl is at least b2 b. We show that cannot be an optimal schedule. We rst note from Lemma 3 that all full batches are sequenced in non-decreasing order of their processing times: consequently, any deferred batch is non-full. Suppose that the deferred batches with respect to batch Bl in are divided into two groups so that the rst group comprises the rst (b 1)2 + 1 of these batches and the second group comprises the remainder of these deferred batches. We observe that, in the rst group, there are at least b deferred batches containing the same number of jobs; let a denote the number of jobs in each of these batches, where a < b. It is useful to represent in the form = (S0;A1;S1;A2; : : : ;Sb 1;Ab;Sb); where Ai, for i = 1; : : : ; b, is a batch that contains a jobs and is deferred with respect to batch Bl, and where Si, for i = 0; : : : ; b, is a block of batches. Note that block S0 contains batch Bl and block Sb contains all deferred batches of the second group. Moreover, p(A1) : : : p(Ab) from Lemma 3. Let p(Si) and jSij denote the total processing time of the batches in block Si and the number of jobs in block Si, respectively, for i = 1; : : : ; b. Since the number of deferred batches with respect to batch Bl is at least b2 b, there are at least b2 b (b 1)2 1 = b 2 batches in Sb, and consequently jSbj b 2. Suppose that we construct full batches A0b a+1; : : : ;A0b from batches Ab a+1; : : : ;Ab by adding the a jobs from each of the batches A1; : : : ;Ab a. For example, the a respective jobs of batch Ai, could be added to batches Ab a+1; : : : ;Ab, for i = 1; : : : ; b a. We now de ne the schedule 1 = (S0;A0b a+1; : : : ;A0b;S1; : : : ;Sb): Our analysis also uses two arti cial schedules 0 and 0 1 for related problems in which some batches are removed and replaced by duplicates of other batches in the schedule. Speci cally, schedule 0 is obtained from by the following transformation. First, we replace each batch Ai for i = 1; : : : ; b a with A1, and each batch Ai for i = b a+ 1; : : : ; b, with Ab. Second, we sequence the b a batches of type A1 in adjacent positions, and also sequence the a batches of type Ab in adjacent positions, with blocks S1; : : : ;Sb 1 in between. Thus, 0 = (S0 ;A1; : : : ;A1; | {z } b a batches S1;S2; : : : ;Sb 1 ;Ab; : : : ;Ab; | {z } a batches Sb): Schedule 0 1 is constructed from 1 by replacing each batch A0i, for i = b a + 1; : : : ; b, with A0b: hence, 0 1 = (S0 ;A0b; : : : ;A0b; | {z } a batches S1;S2; : : : ;Sb 1;Sb): 12 Assume that is an optimal schedule. We prove the lemma by deriving two contradictory inequalities relating Pnj=1 Cj( 0) and Pnj=1 Cj( 0 1). First, we establish that n Xj=1Cj( 0) n X j=1Cj( 0 1): (2) Comparing schedules 0 1 and 1, we observe that there is an increase in processing time of p(A0b) p(A0i) when batch A0i is substituted by A0b, for i = b a+ 1; : : : ; b, and this increase also delays all subsequent jobs in 0 1. From the construction of A0i from Ai, for i = b a + 1; : : : ; b, we observe that p(A0i) = p(Ai). Thus, we deduce that n Xj=1Cj( 0 1) = n X j=1Cj( 1) + b X i=b a+1(p(Ab) p(Ai)) (b i+ 1)b+ b Xl=1 jSlj : (3) We now compare schedules 0 and . First, observe that replacing batch Ai, for i = 1; : : : ; b a, with A1 does not increase the total completion time since p(A1) p(Ai) from Lemma 3. Moreover, Lemma 3 also shows that reordering these A1 batches so that they are sequenced in adjacent positions does not increase the total completion time either. To obtain an upper bound on the increase in total completion time when batch Ai is substituted by Ab, for i = b a+1; : : : ; b, we assume that the increase in processing time of p(Ab) p(Ai) causes a delay to each of the blocks S1; : : : ;Sb. Thus, we obtain n Xj=1Cj( 0) n X j=1Cj( ) + b X i=b a+1(p(Ab) p(Ai)) (b i+ 1)b+ b Xl=1 jSlj : (4) Subtracting (3) from (4) yields n X j=1Cj( 0) n X j=1Cj( 0 1) n X j=1Cj( ) n X j=1Cj( 1) 0; where the latter inequality holds due to the optimality of . Therefore, we have established the desired inequality (2). To obtain the required contradiction, it is su cient to prove that n Xj=1Cj( 0) > n X j=1Cj( 0 1): (5) Let K denote the total completion time of jobs in the schedule de ned by (S0; : : : ;Sb). In schedule 0 1, each of the blocks S1; : : : ;Sb is delayed by time ap(A0b). Since p(A0b) = p(Ab), we deduce that n Xj=1Cj( 0 1) = K + abp(S0) + ab(a+ 1)p(Ab)=2 + ap(Ab) b Xl=1 jSlj: (6) Performing similar calculations for schedule 0, we obtain n Xj=1Cj( 0) = K + a(b a)p(S0) + a(b a)(b a+ 1)p(A1)=2 + (b a)p(A1) b Xl=1 jSlj +a2 b 1 Xl=0 p(Sl) + (b a)p(A1) + a2(a+ 1)p(Ab)=2 + ap(Ab)jSbj: (7) 13 Subtracting (6) from (7) yields n Xj=1Cj( 0) n X j=1Cj( 0 1) = (b a)p(A1) a(b+ a+ 1)=2 + b Xl=1 jSlj ap(Ab) (a+ 1)(b a)=2 + b 1 Xl=1 jSlj + a2 b 1 Xl=1 p(Sl): (8) Rearranging (8), we obtain n Xj=1Cj( 0) n X j=1Cj( 0 1) = (b a)p(A1)((a2 + a b)=2 + jSbj)) +(bp(A1) ap(Ab)) (a+ 1)(b a)=2 + b 1 Xl=1 jSlj +a a b 1 Xl=1 p(Sl) p(A1) b 1 Xl=1 jSlj : (9) Using our previous observation that jSbj b 2, together with b 2 and a 1, shows that (a2 + a b)=2+ jSbj 0. Thus, the rst term in equation (9) is non-negative. Applying Lemma 3 to the batches Bl and A1 in , we obtain p(Bl)=b p(A1)=a. Since batch Ab is deferred with respect to batch Bl, we have that p(Ab) < p(Bl). Combining these inequalities yields p(Ab)=b < p(A1)=a. Thus, the second term in equation (9) is strictly positive. A further application of Lemma 3 to batch A1 and to all of the batches in blocks S1; : : : ;Sb 1 in yields p(A1)=a Pb 1 l=1 p(Sl)=Pb 1 l=1 jSlj. This establishes that the third term in equation (9) is non-negative. We have now proved that inequality (5) holds, which contradicts (2). Therefore, is not an optimal schedule. This implies that the number of deferred batches with respect to any full batch in an optimal schedule is at most b2 b 1. We now present a backward dynamic programming algorithm. that uses state variables to identify deferred batches. Lemma 5 establishes an upper bound on the number of state variables of this type. Recall our assumption that the jobs have been re-indexed according to the shortest processing time (SPT) rule. We also assume that all processing times are distinct, which can be achieved if necessary by perturbation. Let be a schedule that contains jobs Jj ; : : : ; Jn, but not Jj 1, and also contains non-full batches B1; : : : ;Br, where p(B1) : : : p(Br), which are deferred with respect to the batch containing job Jj 1 that remains to be scheduled. Processing of the rst batch in starts at time zero. From Lemma 2, we may assume that Bl = fJjl ; : : : ; Jj0 lg, where j 0 l < jl+1 for l = 1; : : : ; r and jr+1 = j. Further, Lemma 4 shows that these deferred batches may be assumed to appear in in the order B1; : : : ;Br. We also assume that r b2 b 1 in accordance with Lemma 5. If r 6= 0, then Lemma 4 shows the batch containing Jj 1 must be full; therefore, this batch is fJj b; : : : ; Jj 1g, and j 0 r < j b. We claim that knowledge of the indices of initial jobs j1; : : : ; jr allows us to identify, in O(r) time, the indices of nal jobs j 0 1; : : : ; j 0 r, and consequently the exact contents of each of the batches B1; : : : ;Br. To justify this claim, we show how to construct Bl, for l = 1; : : : ; r. The set fJjl ; : : : ; Jjl+1 1g comprises batch Bl and possible other full batches: except for Bl, there are no non-full batches since 14 the resulting schedule would not be consistent with Lemma 4. Thus, the number of jobs in batch Bl is (jl+1 jl) mod b, from which we deduce that j 0 l = jl 1+(jl+1 jl) mod b. Since we do not allow empty batches, the choice of initial job indices must satisfy (jl+1 jl) mod b 6= 0 for j = 1; : : : ; r. We have now established our claim. We de ne to be in state (j; j1; : : : ; jr). If r = 0, then we write the state as (j; ), where is a symbol for empty. A schedule in state (j; ) is created by taking one of the following decisions in a previous state: add a batch containing job Jj . A full or non-full batch fJj ; : : : ; Jk 1g, where j+1 k j+b, is inserted at the beginning of some previous schedule in state (k; ). add a full batch that does not contain job Jj. A full batch fJk; : : : ; Jk+b 1g, where j < k n b+ 1, is inserted at the beginning of some previous schedule in state (k + b; j1; : : : ; jr), where the corresponding deferred batches B1; : : : ;Br satisfy the relationship B1 [ : : :[ Br = fJj ; : : : ; Jk 1g. In the latter case, the previous schedule has batches B1; : : : ;Br that are deferred with respect to the batch that contains job Jk+b 1 . When the full batch fJk; : : : ; Jk+b 1g is scheduled, these batches are no longer deferred. Similarly, to create a schedule in state (j; j1; : : : ; jr) for r 6= 0, we take one of the following decisions: add batch B1. Batch B1 is inserted at the beginning of some previous schedule in state (j; j2; : : : ; jr). add a full batch containing job Jj . A full batch fJj ; : : : ; Jj+b 1g is inserted at the beginning of some previous schedule in state (j + b; j1; : : : ; jr). add a full batch that does not contain job Jj. A full batch fJk ; : : : ; Jk+b 1g, where j < k n b+1, is inserted at the beginning of some previous schedule in state (k+b; j1; : : : ; jr; j1; : : : ; jr), where the corresponding deferred batches B1; : : : ;Br satisfy the relationship B1 [ : : :[ Br = fJj ; : : : ; Jk 1g. Using the above observations, we can use the state variables to compute j 0 1; : : : ; j 0r and n0, where n0 is the number of jobs in . We assume that such computations are performed for every state that we consider, Let Fj(j1; : : : ; jr), and Fj( ), be the minimum total completion time among all schedules that achieve state (j; j1; : : : ; jr) for r 6= 0, and (j; ), respectively. From our previous observations, we can use the state variables to compute j 0 1; : : : ; j 0r, the nal job indices of deferred batches, and n0, where n0 is the number of scheduled jobs. We assume that such computations are performed for every state that we consider. In our dynamic programming algorithm, the initialization is Fn+1( ) = 0: For j = n; n 1; : : : ; 1, we have recursion equations Fj( ) = min8><>: min j+1 k j+bfFk( ) + n0pk 1g; min j+1 k n b+1;(j1;:::;jr)2HkfFk+b(j1; : : : ; jr) + n0pk+b 1g: 15 Also, for j = n+ 1; n; : : : ; 1, r = 1; : : : ; b2 b 1, and j1; : : : ; jr such that j1 < : : : < jr < j b and (jl+1 jl) mod b 6= 0 for l = 1; : : : ; r, where jr+1 = j, the recursion equations are Fj(j1; : : : ; jr) = min8><>>:Fj(j2; : : : ; jr) + n0pj0 1 ; Fj+b(j1; : : : ; jr) + n0pj+b 1; min j+1 k n b+1;(j1;:::;jr)2HkfFk+b(j1; : : : ; jr; j1; : : : ; jr) + n0pk+b 1g; where Hk is the set of vectors (j1; : : : ; jr) that contain the indices of the initial jobs of deferred batches B1; : : : ; Br, where 1 r b2 b 1 r, such that B1 [ : : :[ Br = fJj ; : : : ; Jk 1g. Note that j1 = j. The optimal solution value is equal to F1( ), and the corresponding optimal schedule is found by backtracking. We now discuss the time and space complexity of our dynamic programming algorithm. There are O(nr+1) state variables (j; j1; : : : ; jr), and consequently O(nb(b 1)) state variables overall. The two terms in the recursion equation for Fj( ) are computed in in O(b) time and O(nb2 b 1) time, respectively. The rst two terms in the equation for Fj(j1; : : : ; jr) are computed in constant time, while the third term is computed in O(nb2 b 1 r) time. Thus, the algorithm requires O(nb(b 1)) time and O(nb(b 1)) space. We have established that the bounded problem of minimizing the total completion time is polynomially solvable for xed b. However, when b is arbitrary, the complexity remains unresolved. 3.1.2 The case of m di erent processing times In this subsection, we present an O(b2m22m) time dynamic programming algorithm for minimizing total completion time for the case of m di erent job processing times. Before proceeding, we introduce some notation that is speci cally needed for the development of this algorithm. Let the distinct processing times be p1 < : : : < pm, and let Sj be the set of all jobs with processing time equal to pj , for j = 1; : : : ; m. Moreover, let bj = bjSjj=bc, for j = 1; : : : ; m, so that bj represents the maximum number of full batches containing jobs in Sj only. We call a job a j-job if its processing time is pj , and we call a batch a j-batch if its longest job is a j-job. We call a j-batch pure if the batch is full and contains j-jobs only; otherwise, it is non-pure. In accordance with Lemmas 3 and 4, we restrict our search to schedules in which batches are sequenced in order of non-decreasing ratios p(Bl)=jBlj, and no batch is deferred with respect to a non-full batch. Instead of using Lemma 2, however, we characterize a set of optimal solutions by properties stipulated in the following lemma. Lemma 6 There exists an optimal schedule with the following properties: (i) (Chandru, Lee and Uzsoy, 1993b) there are bj pure j-batches, for j = 1; : : : ; m; (ii) there is at most one non-pure j-batch, for j = 1; : : : ; m. Proof. To prove property (ii), consider any optimal schedule with more than one non-pure j-batch, for some j, and bj pure j-batches in accordance with property (i). Let B denote one of the non-pure j batches. By interchanging each j-job in a non-pure j-batch other than B with a non-j-job in batch B, we obtain an alternative optimal schedule with one non-pure j-batch. Property (i) states that there are bj pure j-batches, for j = 1; : : : ; m, which from Lemma 3 must be sequenced in order of non-decreasing pj . For the remaining jobs, we enumerate all possible 16 con gurations of full non-pure batches. Since property (ii) shows that we may restrict our attention to schedules which have either zero or one full non-pure j-batch for each j (j = 1; : : : ; m), we need to consider 2m possible combinations. We represent a given con guration of full non-pure batches by the set of indices X f1; : : : ; mg, where j 2 X if and only if there is a full non-pure j-batch. We introduce indicator variables aj;X , where aj;X = 1 if j 2 X , 0 otherwise. Given a set X , we propose a batch lling procedure which nds all other jobs in the corresponding full non-pure batches. Consider any index j, where j 2 X . Since a j-batch is required to have pj as its processing time, it must contain a j-job and be lled with jobs with processing times at most pj . Apart from this upper bound on the processing time, we are free to assign any other b 1 jobs, although it is best to ll the batch with jobs having processing times as large as possible. This observation leads to the batch lling procedure described below. Batch Filling Procedure Input. Any set X of batch indices. Step 0. Initially, set nj;X = jSj j bjb if j = 2 X , and nj;X = jSj j bjb 1 if j 2 X , for j = 1; : : : ; m. Note that nj;X represents the number of j-jobs that remain to be assigned to the non-pure j-batches. Set h = 0. Step 1. Determine the smallest index j such that j 2 X and j > h. If no such index exists, then terminate the procedure with an optimal set of full non-pure batches. Step 2. If Pji=1 ni;X < b 1, then terminate the procedure: it is not possible to ll all non-pure batches speci ed by X . Let i be the largest index i < j for which ni;X + ni+1;X + + nj 1;X + nj;X b 1; (10) Fill the non-pure j-batch with all unassigned jobs from the set Si+1; : : : ;Sj and with b 1 Pjk=i+1 nk;X unassigned i-jobs. Accordingly, we update ni;X = ni;X b + 1 +Pjk=i+1 nk;X and nk;X = 0 for k = i+ 1; : : : ; j. Step 3. Set h = j, and go to Step 1. This procedure can be implemented to run in O(m) time for any given set X . The remaining issue is how to form non-full batches with the remaining jobs, which have not been assigned by the batch lling procedure, and how to interleave these non-full batches with the full batches to minimize total ow time. For ease of exposition, assume that the remaining jobs are J1; : : : ; Jn0 , where these jobs have been indexed according to the SPT rule. Let pj be the processing time of Jj , for each j = 1; : : : ; n0. Note that n0 m(b 1). The following result establishes that there exists an optimal schedule in which, after removal of all full batches, jobs J1; : : : ; Jn0 form an SPT-batch schedule. Lemma 7 There exists an optimal schedule in which the sequence of batches formed by jobs J1; : : : ; Jn0 is (B1; : : : ;Br), where under the SPT indexing Bl = fJjl ; Jjl+1; : : : ; Jjl+1 1g and jl+1 < jl + b, for j = 1; : : : ; r, and 1 = j1 < j2 < : : : < jr < jr+1 = n0 + 1. 17 Proof. The argument used in the proof of Lemma 2 shows that there exists an optimal schedule in which the non-full batches contain jobs with consecutive indices. Lemma 4 establishes that these batches are sequenced in order of increasing processing times. We can restrict our search for an optimal schedule to one which has the following properties: (a) the full batches appear in order of non-decreasing processing times, which follows from Lemma 3; (b) the remaining jobs form non-full batches, where each such batch contains jobs with consecutive indices, and the batches are sequenced in SPT order, which follows from Lemma 7; (c) a complete schedule is found be interleaving the full and non-full batches. If the non-full batches are known, the interleaving can be performed using Lemma 3. However, we propose a dynamic programming algorithm that forms the non-full batches and interleaves the full and non-full batches. For any given X , we apply a backward dynamic programming algorithm in which complete batches, either full or non-full, are added to the beginning of some previous schedule. This algorithm implicitly enumerates all schedules that have properties (a) and (b). Since we are minimizing total completion time, it will automatically give an optimal schedule that possesses property (c) as well. Let be a schedule that satis es properties (a) and (b), that contains all of the full k-batches, for k = i; : : : ; m, and the jobs Jj ; : : : ; Jn0 in non-full batches. Processing of the rst batch starts at time zero. We de ne such a schedule to be in state (i; j). Let Fi(j) be the minimum total completion time for schedules in state (i; j). A schedule in state (i; j) is created by taking one of the following decisions in a previous state: add all full i-batches. The number of full i-batches is equal to bi + ai;X (which may be zero). Inserting these batches at the beginning of some previous schedule in state (i+ 1; j) delays the jobs that are already scheduled by (bi + ai;X ) pi units, and therefore increases the total completion time by (bi+ai;X )(bi+ai;X+1)b pi=2+(n0 j+1+bPmk=i+1(bk+ak;X ))(bi+ai;X ) pi. add a batch containing Jj . A non-full batch fJj ; : : : ; Jk 1g, where j < k minfn0+1; j+b 1g, is inserted at the beginning of some previous schedule in state (i; k). Since this batch has processing time pk 1, the previously scheduled jobs are completed pk 1 units later when this batch is added, and total completion time increases by (n0 j + 1 + bPmk=i(bk + ak;X ))pk 1. We are now ready to give the dynamic programming algorithm for computing an optimal schedule for any given X . The initialization is Fm+1(n0 + 1) = 0; and the recursion for i = m + 1; m; : : :; 1 and j = n0 + 1; n0; : : : ; 1 (where either i < m + 1 or j < n0 + 1) is Fi(j) = min8>>><>>>:Fi+1(j) + (bi + ai;X )(bi + ai;X + 1)b pi=2 +(n0 j + 1+ b m P k=i+1(bk + ak;X ))(bi + ai;X ) pi min j m X h=1 3m Xi=1 iW +W: Using the inequality (m h)mA+ hA m2A in the expression for dm yields dm m X h=1 3m Xi=1 iW +m3A; which shows that T > dm, and the schedule is not feasible. Jobs Ji;1, for i = 1; : : : ; 3m, are each contained in di erent batches which are completed by time d1. Since P3m i=1 pi;1 >P3m i=1 iW = d1 (m 1)mA A d1 W , these 3m batches must be sequenced in the rst 3m positions of the schedule. It is not possible for both Ji;2 and J3m+i;2 to be scheduled in the rst block of 3m batches. Since Ji;2 and J3m+i;2 are identical, we may assume that jobs J2;i, for i = 1; : : : ; 3m, are each contained in di erent batches which are not sequenced in the rst 3m positions. To achieve the deadline d2, these batches must form a second block which are sequenced in positions 3m + 1; : : : ; 6m. Repetition of this argument shows that there is a block of 3m batches which contain jobs Ji;j for i = 1; : : : ; 3m that are sequenced in positions 3(j 1)m+ 1; : : : ; 3jm, respectively, for j = 1; : : : ; m. Moreover, the batch containing job Ji;j also contains either Ji;0, J3m+i;j or J3m+i;j+1 (for j 6= m). The batch containing job Ji;j has processing time pi;j unless it contains job Ji;0 in which case it has processing time pi;0. We identify the batches to which jobs J1;0; : : : ; J3m;0 are assigned in order to de ne a partition X1; : : : ;Xm of the index set f1; : : : ; 3mg. Speci cally, i 2 Xj if fJi;j ; Ji;0g is a batch. Since all batches containing jobs Ji;j for i = 1; : : : ; 3m must be completed by time dj , we obtain j X h=1 X i62Xh pi;h + X i2Xh pi;0 dj ; j = 1; : : : ; m; which can be expressed as j X h=1 h A X i2Xh ai 0; j = 1; : : : ; m: (11) Suppose that at least one of the inequalities in (11) is strict. Then by forming a linear combination of the m inequalities with positive coe cients 1=j 1=(j + 1) for j = 1; : : : ; m 1, and 1=m for j = m, we obtain a strictly positive value. This relationship is expressed as m 1 X j=1 1j 1 j + 1 j X h=1 h A X i2Xh ai + 1 m m X h=1 h A X i2Xh ai > 0; 20 which can be rewritten asmXh=1 h A Xi2Xh ai m 1Xj=h 1j1j + 1 + 1m = mAmXh=1 Xi2Xh ai > 0:However, this inequality contradicts P3mi=1 ai = mA, which is obtained from the de nition of 3-Partition. Therefore, the left-hand side of each inequality in (11) is equal to zero. This impliesthatPi2Xj ai = A for j = 1; : : : ; m, which shows that X1; : : : ;Xm de ne a solution to 3-PartitionCorollary 1 The bounded problems of minimizing the maximum lateness Lmax, the number oftardy jobsPnj=1 Uj , and the total tardinessPnj=1 Tj are unary NP-hard, even if b = 2.3.3 Restricted number of batchesIn this section, we consider the bounded problem of minimizing any regular objective function whenthe schedule is constrained to contain at most r batches. We show that this problem can be solvedin (nr+3) time, which is polynomial when r is xed.Note that, if the longest job of each batch is speci ed along with the order in which the rbatches are sequenced, then it is straightforward to compute the processing times p(B1); : : : ; p(Br)and completion times C(B1); : : : ; C(Br) of the batches. The problem then reduces to one of assigningeach of the remaining jobs to the r batches so that no batch contains more than b jobs and no jobis assigned to a batch whose designated longest job would be smaller. If job Jj has a deadline dj ,then we must also ensure that Cj dj .>From the above observations, the cost cij of assigning any of the n r remaining jobs Jj(j = 1; : : : ; n) to batch Bi (i = 1; : : : ; r) iscij = 1;if p(Bi) < pj or C(Bi) > dj ,fj(C(Bi)); otherwise.Thus, the problem of minimizing a minsum cost function for given batch processing times and agiven processing order of the r batches reduces to a bipartite weighted matching problem, whichcan be solved in O(n3) time (Lawler, 1976).To select the designated longest jobs, each of thenr possible choices must be considered. Foreach selection, there are r! batch sequences. For xed r, there are O(nr) selections of longest jobsand batch processing orders, each of which requires a a bipartite weighted matching problem to besolved. Thus, the problem is solvable in O(nr+3) time, which is polynomial.To minimize a regular minmax objective function, we adopt a similar approach, except that it isnecessary to solve a minmax bipartite weighted matching problem. Since this matching problem issolvable in O(n3) time (Lawler, 1976), the overall time requirement for a minmax objective functionis also O(nr+3).4 Concluding remarksThis paper is a rst step towards providing a complexity mapping of single-machine batchingproblems, in which the processing time of a batch is dictated by its longest job. We refer to Table 121 in the introduction for a summary of our results. The mapping is not complete, since the followingcomplexity issues remain open: binary NP-hardness for the unbounded problem of minimizing thetotaltardinessPnj=1 Tj (which is pseudopolynomially solvable), and binary and unary NP-hardnessfor the bounded problems of minimizing the total completion timePnj=1 Cj for arbitrary b and ofminimizing the total weighted completion timePnj=1 wjCj for xed and arbitrary b.Our analysis does not consider problems with unequal job release dates. For the unboundedmodel, a di erent approach to that in Section 2 is required, since we may no longer restrict oursearch to SPT-batch schedules. These problems are therefore likely to be much more di cultthan their counterparts with equal job release dates. There is one exception: since the problem ofminimizing the makespan subject to unequal job release dates is the mirror image of minimizingthe maximum lateness with equal release dates, we can solve the makespan problem in O(n2) timeusing the algorithm for minimizing the maximum lateness that is presented in Section 2.5.For the bounded model with unequal release dates, all criteria that we consider give rise tounary NP-hard problems. Table 1 shows that most such problems are already unary NP-hard withequal release dates (cf. Table 1), while minimizing the total completion time subject to releasedates is unary NP-hard even if b = 1 (Lenstra et al., 1977). Minimizing the makespan subjectto release dates is unary NP-hard as well, since we have shown in Section 3.2 that the equivalentmirror image problem of minimizing the maximum lateness is unary NP-hard for b = 2 .Another extension to the model involves scheduling jobs with equal release dates on m identicalparallel machines. For the unbounded model, it is not di cult to prove that there exists anoptimal solution which is an SPT-batch schedule for an arbitrary regular objective function. Weclaim therefore that any such parallel-machine batching problems for which the SPT-batch propertystill holds can be solved by dynamic programming in pseudopolynomial time for a xed number ofmachines.ReferencesAhmadi, J.H., R.H. Ahmadi, S. Dasu and C.S. Tang. 1992. Batching and scheduling jobson batch and discrete processors. Operations Research 39, 750{763.Albers, S. and P. Brucker. 1993. The complexity of one-machine batching problems. DiscreteApplied Mathematics 47, 87{107.Blum, N., R.W. Floyd, V. Pratt, R.L. Rivest and R.E. Tarjan. 1973. Time bounds forselection. Journal of Computer and Systems Sciences 7, 448{461.Chandru, V., C.-Y. Lee and R. Uzsoy. 1993a. Minimizing total completion time on batchprocessing machines. International Journal of Production Research 31, 2097{2122.Chandru, V., C.-Y. Lee and R. Uzsoy. 1993b. Minimizing total completion time on a batchprocessing machine. Operations Research Letters 13, 61{65.Cheng, T.C.E. and M.Y. Kovalyov. 1995. Addendum to C.-Y. Lee, R. Uzsoy and L.A.Martin-Vega (1992). Working Paper, Institute of Engineering Cybernetics, Minsk, Belarus.Hochbaum, D.S. and D. Landy. 1994. Algorithms and heuristics for scheduling semiconductorburn-in-operations. Technical report, Engineerings Systems Research Center, University ofCalifornia, Berkeley.Lawler, E.L. 1976. Combinatorial Optimization: Networks and Matroids. Holt, Rinehart andWinston, New York.22 Lawler, E.L., J.K. Lenstra, A.H.G. Rinnooy Kan and D.B. Shmoys. 1993. Sequenc-ing and scheduling: algorithms and complexity. S.C. Graves, P.H. Zipkin, A.H.G. RinnooyKan (eds.). Logistics of Production and Inventory; Handbooks in Operations Research andManagement Science, Vol. 4, North-Holland, Amsterdam, 445{522.Lee, C.-Y., R. Uzsoy and L.A. Martin-Vega. 1992. E cient algorithms for schedulingsemiconductor burn-in operations. Operations Research 40, 764{775.Lenstra, J.K., A.H.G. Rinnooy Kan and P. Brucker. 1977. Complexity of machinescheduling problems. Annals of Discrete Mathematics 1, 343{362.Schonhage, A., M. Patterson and N. Pippenger. 1976. Finding the median. Journal ofComputer and Systems Sciences 13, 184{199.Uzsoy, R. 1995. Scheduling batch processing machines with incompatible job families. Interna-tional Journal of Production Research 33, 2685{2708.van Hoesel, S., A. Wagelmans, and B. Moerman. 1994. Using geometric techniques toimprove dynamic programming algorithms for the economic lot-sizing problem and extensions.European Journal of Operational Research 75, 312{331.Webster, S. and K.R. Baker. 1995. Scheduling groups of jobs on a single machine. OperationsResearch 43, 692{703.23